A variety of public key cryptography protocols are known for encoding information, authenticating entities to one another, and electronically signing messages. Examples of such protocols include RSA, El Gamal, Schnorr and Fiat Shamir. A common feature of public key cryptography protocols is the fact that they employ large prime numbers, with typical lengths in the range of 512–2048 bits, to form one or more keys of the protocol. Some of these cryptosystems, such as RSA for example, require the random generation of several distinct prime numbers. Thus, generating prime numbers is an essential tool in public-key cryptography.
When efficiency is not a concern, one of the simplest ways to generate a random prime number is to select a random number q, and test it for primality. If the test is unsuccessful, the value for q is incremented by one, and the test is rerun. Since all prime numbers except two are odd, a straightforward improvement on this technique is to chose q as an odd value, and to update it in increments of two for each successive iteration of the test. However, this technique can become computationally intensive and is therefore not practical in a number of situations when large-sized numbers are employed.
To facilitate the random number selection process, several techniques have been developed that make it possible to more efficiently calculate the greatest common denominator of two numbers, and thereby determine whether they are co-prime. Examples of these techniques include Binary GCD, Extended GCD and the Lehmer formula. While these techniques exhibit excellent asymptotic complexity for numbers of extremely large size, they are difficult to program in an environment having limited processing resources, such as a smart card or other portable electronic device. In addition, they provide relatively poor performance for operations involving numbers of the size typically employed in the smart-card environment, e.g. in the range of 512 to 1024 bits. To increase the performance, it is possible to equip the card with an arithmetic coprocessor to carry out some of the operations of the primality test. However, other operations that are performed as part of the test, such as parity checking and binary shifts, are not compatible with the functionality typically offered in an arithmetic coprocessor. As a result, the overall performance still suffers.
To address these issues, an improved technique for generating random prime numbers is disclosed in commonly assigned application Ser. No. 09/818,658, the contents of which are incorporated herein by reference. Briefly, the method disclosed in this application comprises an algorithm that receives, as input, the values π and λ, where π=Πp1 is the product of a set of k distinct primary numbers p1, and λ is the Carmichael function and is defined as:λ=LCM(λ(p1), . . . ,λ(pk)) and λ(p1)=pi−1,in which LCM designates the least common multiple. The output of the algorithm comprises a random element x of the set (Z/πZ)* with uniform distribution. The algorithm essentially comprises the following steps:                1. Select a random number x<π with uniform distribution;        2. Calculate xλ(modπ), and if this value equals 1 return x;        3. Otherwise, x=x+1 and loop back to step 2.        
It is an object of the present invention to improve upon the technique disclosed in the prior pending application. In particular, that technique requires, on average, λ/φ(π) modular exponentiations, modulo π, with the exponent λ, where φ(π)=Πki=o pi−1. It is the objective of the present invention to reduce the time necessary to carry out these arithmetic operations.